DEFINITION MODULE  XStrings;

(*****************************************************************************)
(* In diesem Modul sind weiterfuehrende Prozeduren fuer den in "Strings"     *)
(* definierten Stringtyp enthalten. Alles grundsaetzliche, was dort ueber    *)
(* die Strings gesagt wurde, gilt auch fuer dieses Modul.                    *)
(*___________________________________________________________________________*)
(*  05-Dez-89 , Holger Kleinschmidt                                          *)
(*****************************************************************************)

FROM  Chars    IMPORT  (* TYPE *)  CharConvert, CharClassTest;
FROM  Strings  IMPORT  (* TYPE *)  CompareResult;

(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)


 PROCEDURE  FillStr ((* EIN/ -- *)     fuellung : CHAR;
                     (* EIN/ -- *)     anzahl   : CARDINAL;
                     (* -- /AUS *) VAR string   : ARRAY OF CHAR );

(*-------------------------------------------------------------------------
 | <string> bekommt die Laenge <anzahl> und ist vollstaendig mit <fuellung>|
 | belegt. Ist <anzahl> gleich Null oder groesser als die maximal moegliche|
 | Laenge, wird bis zum Feldende aufgefuellt.                              |
  -------------------------------------------------------------------------*)


 PROCEDURE  ConvertStr ((* EIN/ -- *)     quelle : ARRAY OF CHAR;
                        (* EIN/ -- *)     convert: CharConvert;
                        (* -- /AUS *) VAR ziel   : ARRAY OF CHAR;
                        (* -- /AUS *) VAR vollst : BOOLEAN       );

(*-------------------------------------------------------------------------
 | <quelle> wird zeichenweise mittels  <convert> umgewandelt, und das      |
 | Ergebnis wird <ziel> zugewiesen. Kann <ziel> nicht den gesamten String  |
 | aufnehmen, wird nur bis zum Ende von <ziel> zugewiesen und <vollst> auf |
 | FALSE gesetzt.                                                          |
 | Als Konvertierungsfunktion eignen sich zum Beispiel die Prozeduren aus  |
 | "Char" ( "LowerCaseGerman","LowerCaseASCIIGerman","CAPGerman",          |
 | "CAPGermanASCII","ToAtariGerman","ToASCIIGerman" ).                     |
  -------------------------------------------------------------------------*)


 PROCEDURE  EqualConvStr ((* EIN/ -- *) string1,
                          (* EIN/ -- *) string2 : ARRAY OF CHAR;
                          (* EIN/ -- *) convert : CharConvert    ): BOOLEAN;

(*-------------------------------------------------------------------------
 | Die mittels <convert> umgewandelten Strings werden zeichenweise mitein- |
 | ander verglichen; die Endebedingung spielt keine Rolle ( siehe "Equal"  |
 | in "Strings" ). Als Konvertierungsfunktion koennen die Prozeduren aus   |
 | "Chars" benutzt werden.                                                 |
  -------------------------------------------------------------------------*)


 PROCEDURE  CompareCAPStr ((* EIN/ -- *) string1,
                           (* EIN/ -- *) string2:ARRAY OF CHAR ):CompareResult;

(*---------------------------------------------------------------------------
 | Vergleicht <string1> und <string2> zeichenweise miteinander; es wird      |
 | nicht zwischen Gross- und Kleinschreibung unterschieden.                  |
 |                                                                           |
 | Das Ergebnis wird folgendermassen gebildet ( lexikographische Ordnung ):  |
 |  - Beim ersten Zeichen von <string1>, das kleiner (groesser) als das ent- |
 |    sprechende Zeichen bei <string2> ist, wird <Less> (<Greater>) zurueck- |
 |    geliefert.                                                             |
 |  - Sind beide Strings gleichlang ( Endekennung spielt keine Rolle !! ),   |
 |    und stimmen die Zeichen bis zum Ende ueberein, wird 'equal' zurueckge- |
 |    liefert.                                                               |
 |  - Ist <string1> kuerzer (laenger) als <string2> und stimmen bis zur      |
 |    Laenge von <string1> alle Zeichen ueberein, wird 'less' ('greater')    |
 |    zurueckgeliefert.                                                      |
  ---------------------------------------------------------------------------*)



 PROCEDURE  LeftPosConvStr  ((* EIN/ -- *) muster  : ARRAY OF CHAR;
                             (* EIN/ -- *) start   : CARDINAL;
                             (* EIN/ -- *) string  : ARRAY OF CHAR;
                             (* EIN/ -- *) convert : CharConvert;
                             (* EIN/ -- *) links   : BOOLEAN       ): CARDINAL;

 PROCEDURE  RightPosConvStr ((* EIN/ -- *) muster  : ARRAY OF CHAR;
                             (* EIN/ -- *) start   : CARDINAL;
                             (* EIN/ -- *) string  : ARRAY OF CHAR;
                             (* EIN/ -- *) convert : CharConvert;
                             (* EIN/ -- *) links   : BOOLEAN       ): CARDINAL;

(*---------------------------------------------------------------------------
 | Die Prozeduren suchen ab dem <start>-ten Zeichen zum Ende (Anfang) von    |
 | <string> hin nach dem ersten Auftreten von <muster> in <string>.          |
 | Sowohl <string> als auch <muster> werden zuvor zeichenweise mittels       |
 | <convert> in die gewuenschte Darstellung umgewandelt ( z.B. Grossschrei-  |
 | bung unter Beruecksichtigung deutscher Umlaute ).                         |
 | Zurueckgegeben wird die Position des ersten Zeichens von <muster> in      |
 | <string> oder Null, falls <muster> nicht oder nicht vollstaendig in       |
 | <string> auftritt.                                                        |
 |                                                                           |
 |  - Mit <links> laesst sich bestimmen, ob die Position des Musters vom     |
 |    Anfang oder vom Ende von <string> gerechnet wird. Beispiel:            |
 |      <string> = 'abcdefg', <muster> = 'bc',                               |
 |    Falls <links> = TRUE, liefert LeftPos 2, sonst 6.                      |
 |    Dadurch lassen sich auf einfache Weise "LeftString" und "RightString"  |
 |    benutzen.                                                              |
 |  - <start> = 0: Bei "LeftPos"  <=> <start> = 1,                           |
 |    bei "RightPos" <=> <start> = Length( quelle ) - Length( muster ) + 1,  |
 |    d.h. es wird soweit rechts wie moeglich mit der Suche begonnen.        |
 |  - Liegt <start> ausserhalb von <string>, oder ist <muster> ein Leer-     |
 |    string, wird Null zurueckgegeben. Bei "RightPos" wird ein ausserhalb   |
 |    des Strings liegendes <start> wie <start> = 0 behandelt.               |
  ---------------------------------------------------------------------------*)



 PROCEDURE  LeftPosInSet     ((* EIN/ -- *) charSet: ARRAY OF CHAR;
                              (* EIN/ -- *) start  : CARDINAL;
                              (* EIN/ -- *) string : ARRAY OF CHAR;
                              (* EIN/ -- *) links  : BOOLEAN       ):CARDINAL;

 PROCEDURE  LeftPosNotInSet  ((* EIN/ -- *) charSet: ARRAY OF CHAR;
                              (* EIN/ -- *) start  : CARDINAL;
                              (* EIN/ -- *) string : ARRAY OF CHAR;
                              (* EIN/ -- *) links  : BOOLEAN       ):CARDINAL;

 PROCEDURE  RightPosInSet    ((* EIN/ -- *) charSet: ARRAY OF CHAR;
                              (* EIN/ -- *) start  : CARDINAL;
                              (* EIN/ -- *) string : ARRAY OF CHAR;
                              (* EIN/ -- *) links  : BOOLEAN       ):CARDINAL;

 PROCEDURE  RightPosNotInSet ((* EIN/ -- *) charSet: ARRAY OF CHAR;
                              (* EIN/ -- *) start  : CARDINAL;
                              (* EIN/ -- *) string : ARRAY OF CHAR;
                              (* EIN/ -- *) links  : BOOLEAN       ):CARDINAL;

(*---------------------------------------------------------------------------
 | Die Prozeduren suchen ab dem <start>-ten Zeichen zum Ende ( Anfang ) von  |
 | <string> hin nach einem Zeichen von <string>, dass ( nicht ) in <charSet> |
 | auftritt. Zurueckgegeben wird die Position dieses Zeichens oder Null,     |
 | falls kein ( nur ) Zeichen aus <charSet> in <string> auftritt (auftreten).|
 |                                                                           |
 |  - Randbedingungen wie bei "Left/RightPosConvStr"                         |
  ---------------------------------------------------------------------------*)


 PROCEDURE  LeftPosInClass    ((* EIN/ -- *) inClass: CharClassTest;
                               (* EIN/ -- *) start  : CARDINAL;
                               (* EIN/ -- *) string : ARRAY OF CHAR;
                               (* EIN/ -- *) links  : BOOLEAN       ):CARDINAL;

 PROCEDURE  LeftPosNotInClass ((* EIN/ -- *) inClass: CharClassTest;
                               (* EIN/ -- *) start  : CARDINAL;
                               (* EIN/ -- *) string : ARRAY OF CHAR;
                               (* EIN/ -- *) links  : BOOLEAN       ):CARDINAL;

 PROCEDURE  RightPosInClass   ((* EIN/ -- *) inClass: CharClassTest;
                               (* EIN/ -- *) start  : CARDINAL;
                               (* EIN/ -- *) string : ARRAY OF CHAR;
                               (* EIN/ -- *) links  : BOOLEAN       ):CARDINAL;

 PROCEDURE  RightPosNotInClass((* EIN/ -- *) inClass: CharClassTest;
                               (* EIN/ -- *) start  : CARDINAL;
                               (* EIN/ -- *) string : ARRAY OF CHAR;
                               (* EIN/ -- *) links  : BOOLEAN       ):CARDINAL;

(*---------------------------------------------------------------------------
 | Die Prozeduren suchen ab dem <start>-ten Zeichen zum Ende ( Anfang ) von  |
 | <string> hin nach einem Zeichen von <string>, dass ( nicht ) in die Klasse|
 | von Zeichen gehoert, die durch <inClass> geprueft wird.                   |
 | Zurueckgegeben wird die Position dieses Zeichens oder Null, falls kein    |
 | ( alle ) Zeichen von <string> in diese Klasse gehoert ( gehoeren ).       |
 |                                                                           |
 |  - Randbedingungen wie bei "Left/RightPosConvStr"                         |
  ---------------------------------------------------------------------------*)



 PROCEDURE  TrimLeft  ((* EIN/AUS *) VAR string : ARRAY OF CHAR );

 PROCEDURE  TrimRight ((* EIN/AUS *) VAR string : ARRAY OF CHAR );

 PROCEDURE  TrimStr   ((* EIN/AUS *) VAR string : ARRAY OF CHAR );

(*---------------------------------------------------------------------------
 | Entfernt alle fuehrenden und/oder abschliessenden Leerzeichen von <string>|
  ---------------------------------------------------------------------------*)

END  XStrings.
